* prepare to eliminate char strings from garmin_fs_t.
* retire cet_covnert_strings
The only use was for garmin specific data(gmsd).
gmsd is migrated from char strings to QStrings,
and any necessary conversions are handled within the formats using
gmsd.
This takes main out of the string conversion business.
* fix gmsd related memory leaks.
and eliminate a little back and forth between
char strings and QStrings.
csv_stringtrim has 3 signatures:
1. char*,char*,int returning char* that must be free'd.
2. QString,QString returning QString
3. QString,QString,int returing QString
We may want to consider replacing 2. with 3. and a default for
the 3rd argument.
result->fs.type = FS_AN1W;
result->fs.copy = Copy_AN1_Waypoint;
result->fs.destroy = Destroy_AN1_Waypoint;
- result->fs.convert = nullptr;
return result;
}
result->fs.type = FS_AN1V;
result->fs.copy = Copy_AN1_Vertex;
result->fs.destroy = Destroy_AN1_Vertex;
- result->fs.convert = nullptr;
return result;
}
result->fs.type = FS_AN1L;
result->fs.copy = Copy_AN1_Line;
result->fs.destroy = Destroy_AN1_Line;
- result->fs.convert = nullptr;
return result;
}
static cet_cs_alias_t* cet_cs_alias;
static int cet_cs_alias_ct = 0;
static int cet_cs_vec_ct = 0;
-static int cet_output = 0;
/* %%% fixed inbuild character sets %%% */
}
}
}
-
-/* -------------------------------------------------------------------- */
-
-static void
-cet_flag_waypt(const Waypoint* wpt)
-{
- (const_cast<Waypoint*>(wpt))->wpt_flags.cet_converted = 1;
-}
-
-static void
-cet_flag_all()
-{
- waypt_disp_all(cet_flag_waypt);
- route_disp_all(nullptr, nullptr, cet_flag_waypt);
- track_disp_all(nullptr, nullptr, cet_flag_waypt);
-}
-
-/* -------------------------------------------------------------------- */
-/* %%% complete data strings transformation %%% */
-/* -------------------------------------------------------------------- */
-
-static char* (*converter)(const char*) = nullptr;
-
-/* two converters */
-
-static char*
-cet_convert_to_utf8(const char* str)
-{
- return cet_str_any_to_utf8(str, global_opts.charset);
-}
-
-static char*
-cet_convert_from_utf8(const char* str)
-{
- return cet_str_utf8_to_any(str, global_opts.charset);
-}
-
-/* cet_convert_string: internal used within cet_convert_strings process */
-
-char*
-cet_convert_string(char* str)
-{
- if (str == nullptr) {
- return nullptr; /* return origin if empty or NULL */
- } else if (*str == '\0') {
- return str;
- }
-
- char* res = converter(str);
- xfree(str);
- return res;
-}
-
-const char*
-cet_convert_string(const QString& str)
-{
- // FIXME: this is really weird. Since cet_convert_string wants to free
- // its argument (!) we make a duplicate just to satisfy that kind of goofy
- // requirement.
- return cet_convert_string(xstrdup(str));
-}
-
-/* cet_convert_waypt: internal used within cet_convert_strings process */
-
-static void
-cet_convert_waypt(const Waypoint* wpt)
-{
- auto* w = const_cast<Waypoint*>(wpt);
-
- if ((cet_output == 0) && (w->wpt_flags.cet_converted != 0)) {
- return;
- }
-
- w->wpt_flags.cet_converted = 1;
-
- format_specific_data* fs = wpt->fs;
- while (fs != nullptr) {
- if (fs->convert != nullptr) {
- fs->convert(fs);
- }
- fs = fs->next;
- }
-}
-
-/* %%% cet_convert_strings (public) %%%
- *
- * - Convert all well known strings of GPS data from or to UTF-8 -
- *
- * !!! One of "source" or "target" must be internal cet_cs_vec_utf8 or NULL !!! */
-
-void
-cet_convert_strings(const cet_cs_vec_t* source, const cet_cs_vec_t* target)
-{
- const char* cs_name_from, *cs_name_to;
-
- converter = nullptr;
-
- if ((source == nullptr) || (source == &cet_cs_vec_utf8)) {
- if ((target == nullptr) || (target == &cet_cs_vec_utf8)) {
- cet_flag_all();
- return;
- }
-
- cet_output = 1;
-
- converter = cet_convert_from_utf8;
- cs_name_from = cet_cs_vec_utf8.name;
- cs_name_to = target->name;
- } else {
- if ((target != nullptr) && (target != &cet_cs_vec_utf8)) {
- fatal(MYNAME ": Internal error!\n");
- }
-
- cet_output = 0;
-
- converter = cet_convert_to_utf8;
- cs_name_to = cet_cs_vec_utf8.name;
- cs_name_from = source->name;
- }
-
- if (global_opts.debug_level > 0) {
- printf(MYNAME ": Converting from \"%s\" to \"%s\"", cs_name_from, cs_name_to);
- }
-
- waypt_disp_all(cet_convert_waypt);
- route_disp_all(nullptr, nullptr, cet_convert_waypt);
- track_disp_all(nullptr, nullptr, cet_convert_waypt);
-
- cet_output = 0;
-
- if (global_opts.debug_level > 0) {
- printf(", done.\n");
- }
-}
[[deprecated]] char* cet_str_any_to_any(const char* src, const cet_cs_vec_t* src_vec, const cet_cs_vec_t* dest_vec);
-/* cet_convert_string: !!! ONLY VALID WITHIN 'cet_convert_strings' process !!! */
-char* cet_convert_string(char* str);
-const char* cet_convert_string(const QString& str);
-
/* gpsbabel extensions */
void cet_convert_init(const QString& cs_name, int force);
-void cet_convert_strings(const cet_cs_vec_t* source, const cet_cs_vec_t* target);
void cet_convert_deinit();
#endif // CET_UTIL_H_INCLUDED_
using fs_destroy = void (*)(void*);
using fs_copy = void (*)(void**, void*);
-using fs_convert = void (*)(void*);
struct format_specific_data {
long type{0};
fs_destroy destroy{nullptr};
fs_copy copy{nullptr};
- fs_convert convert{nullptr};
};
class gb_color
public:
wp_flags() :
shortname_is_synthetic(0),
- cet_converted(0),
fmt_use(0),
temperature(0),
proximity(0),
is_split(0),
new_trkseg(0) {}
unsigned int shortname_is_synthetic:1;
- unsigned int cet_converted:1; /* strings are converted to UTF8; interesting only for input */
unsigned int fmt_use:2; /* lightweight "extra data" */
/* "flagged fields" */
unsigned int temperature:1; /* temperature field is set */
static garmin_fs_t*
gmsd_init(Waypoint* wpt)
{
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (gmsd == nullptr) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&wpt->fs, (format_specific_data*) gmsd);
str += " ";
str += hnum;
}
- GMSD_SETSTRQ(addr, str);
+ garmin_fs_t::set_addr(gmsd, str);
}
- if ((str = read_wcstr(0), !str.isEmpty())) { /* city */
+ if (!(str = read_wcstr(0)).isEmpty()) { /* city */
gmsd = gmsd_init(wpt);
- GMSD_SETSTRQ(city, str);
+ garmin_fs_t::set_city(gmsd, str);
}
(void) read_wcstr(1); /* unknown */
- if ((str = read_wcstr(0), !str.isEmpty())) { /* postcode */
+ if (!(str = read_wcstr(0)).isEmpty()) { /* postcode */
gmsd = gmsd_init(wpt);
- GMSD_SETSTRQ(postal_code, str);
+ garmin_fs_t::set_postal_code(gmsd, str);
}
(void) read_wcstr(1); /* unknown */
static void
destinator_wpt_disp(const Waypoint* wpt)
{
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
write_wcstr(DST_DYN_POI);
write_wcstr((!wpt->shortname.isEmpty()) ? wpt->shortname : "WPT");
write_wcstr((!wpt->notes.isEmpty()) ? wpt->notes : wpt->description);
write_wcstr(nullptr); /* house number */
- write_wcstr(GMSD_GET(addr, NULL)); /* street */
- write_wcstr(GMSD_GET(city, NULL)); /* city */
+ write_wcstr(garmin_fs_t::get_addr(gmsd, nullptr)); /* street */
+ write_wcstr(garmin_fs_t::get_city(gmsd, nullptr)); /* city */
write_wcstr(nullptr); /* unknown */
- write_wcstr(GMSD_GET(postal_code, NULL)); /* postcode */
+ write_wcstr(garmin_fs_t::get_postal_code(gmsd, nullptr)); /* postcode */
write_wcstr(nullptr); /* unknown */
gbfputint32(0, fout);
parse_line(char* buff, int index, const char* delimiter, Waypoint* wpt)
{
char* cin;
- garmin_fs_p gmsd = GMSD_FIND(wpt);
+ garmin_fs_p gmsd = garmin_fs_t::find(wpt);
while ((cin = csv_lineparse(buff, delimiter, "", index++))) {
case WAYPT__OFS + 4:
if (strcmp(cin, "S+C") == 0) {
- GMSD_SET(display, gt_display_mode_symbol_and_comment);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_comment);
} else if (strcmp(cin, "S") == 0) {
- GMSD_SET(display, gt_display_mode_symbol);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol);
} else if (strcmp(cin, "S+N") == 0) {
- GMSD_SET(display, gt_display_mode_symbol_and_name);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_name);
}
break;
case WPT_cA_OFS + 4:
case WPT_c4_OFS + 2:
- GMSD_SETSTR(city, cin);
+ garmin_fs_t::set_city(gmsd, cin);
break;
case WPT_cA_OFS + 5:
case WPT_c4_OFS + 3:
- GMSD_SETSTR(state, cin);
+ garmin_fs_t::set_state(gmsd, cin);
break;
case WPT_cA_OFS + 6:
case WPT_c4_OFS + 4:
- GMSD_SETSTR(cc, cin);
+ garmin_fs_t::set_cc(gmsd, cin);
break;
case WPT_cB_OFS + 1:
case WPT_c6_OFS + 2:
- GMSD_SETSTR(facility, cin);
+ garmin_fs_t::set_facility(gmsd, cin);
break;
case WPT_cB_OFS + 2:
case WPT_c6_OFS + 3:
- GMSD_SETSTR(addr, cin);
+ garmin_fs_t::set_addr(gmsd, cin);
break;
case WPT_cB_OFS + 3: /*cross road */
case WPT_c6_OFS + 4:
- GMSD_SETSTR(cross_road, cin);
+ garmin_fs_t::set_cross_road(gmsd, cin);
break;
case TRKPT__OFS + 2: /* altitude */
case WPT_cD_OFS + 3:
categories = atoi(cin);
if (categories != 0) {
- GMSD_SET(category, atoi(cin));
+ garmin_fs_t::set_category(gmsd, atoi(cin));
}
break;
garmin_fs_t*
garmin_fs_alloc(const int protocol)
{
- garmin_fs_t* result = (garmin_fs_t*)xcalloc(1, sizeof(*result));
+ garmin_fs_t* result = new garmin_fs_t;
result->fs.type = FS_GMSD;
result->fs.copy = (fs_copy) garmin_fs_copy;
result->fs.destroy = garmin_fs_destroy;
- result->fs.convert = garmin_fs_convert;
result->fs.next = nullptr;
result->protocol = protocol;
void
garmin_fs_destroy(void* fs)
{
- garmin_fs_t* data = (garmin_fs_t*) fs;
- if (data != nullptr) {
- garmin_ilink_t* ilinks;
-
- if (data->addr != nullptr) {
- xfree(data->addr);
- }
- if (data->cc != nullptr) {
- xfree(data->cc);
- }
- if (data->city != nullptr) {
- xfree(data->city);
- }
- if (data->country != nullptr) {
- xfree(data->country);
- }
- if (data->cross_road != nullptr) {
- xfree(data->cross_road);
- }
- if (data->facility != nullptr) {
- xfree(data->facility);
- }
- if (data->phone_nr != nullptr) {
- xfree(data->phone_nr);
- }
- if (data->phone_nr2 != nullptr) {
- xfree(data->phone_nr2);
- }
- if (data->fax_nr != nullptr) {
- xfree(data->fax_nr);
- }
- if (data->email != nullptr) {
- xfree(data->email);
- }
- if (data->postal_code != nullptr) {
- xfree(data->postal_code);
- }
- if (data->state != nullptr) {
- xfree(data->state);
- }
+ delete (garmin_fs_t*) fs;
+}
- if ((ilinks = data->ilinks) != nullptr) {
- ilinks->ref_count--;
- if (ilinks->ref_count <= 0) {
- while (ilinks != nullptr) {
- garmin_ilink_t* tmp = ilinks;
- ilinks = ilinks->next;
- xfree(tmp);
- }
+garmin_fs_t::~garmin_fs_t()
+{
+ garmin_ilink_t* links;
+ if ((links = ilinks) != nullptr) {
+ links->ref_count--;
+ if (links->ref_count <= 0) {
+ while (links != nullptr) {
+ garmin_ilink_t* tmp = links;
+ links = links->next;
+ xfree(tmp);
}
}
- xfree(data);
}
}
*dest = nullptr;
return;
}
- *dest = (garmin_fs_t*) xmalloc(sizeof(*src));
-
- /* do not copy interlinks, only increment the reference counter */
- if (src->ilinks != nullptr) {
- src->ilinks->ref_count++;
- }
-
- memcpy(*dest, src, sizeof(*src));
-
- (*dest)->addr = (src->addr != nullptr) ? xstrdup(src->addr) : nullptr;
- (*dest)->cc = (src->cc != nullptr) ? xstrdup(src->cc) : nullptr;
- (*dest)->city = (src->city != nullptr) ? xstrdup(src->city) : nullptr;
- (*dest)->country = (src->country != nullptr) ? xstrdup(src->country) : nullptr;
- (*dest)->cross_road = (src->cross_road != nullptr) ? xstrdup(src->cross_road) : nullptr;
- (*dest)->facility = (src->facility != nullptr) ? xstrdup(src->facility) : nullptr;
- (*dest)->phone_nr = (src->phone_nr != nullptr) ? xstrdup(src->phone_nr) : nullptr;
- (*dest)->phone_nr2 = (src->phone_nr2 != nullptr) ? xstrdup(src->phone_nr2) : nullptr;
- (*dest)->fax_nr = (src->fax_nr != nullptr) ? xstrdup(src->fax_nr) : nullptr;
- (*dest)->email = (src->email != nullptr) ? xstrdup(src->email) : nullptr;
- (*dest)->postal_code = (src->postal_code != nullptr) ? xstrdup(src->postal_code) : nullptr;
- (*dest)->state = (src->state != nullptr) ? xstrdup(src->state) : nullptr;
+ *dest = new garmin_fs_t(*src);
}
-void garmin_fs_convert(void* fs)
+garmin_fs_t::garmin_fs_t(const garmin_fs_t& other) :
+ fs(other.fs),
+ flags(other.flags),
+ protocol(other.protocol),
+ icon(other.icon),
+ wpt_class(other.wpt_class),
+ display(other.display),
+ category(other.category),
+ city(other.city),
+ facility(other.facility),
+ state(other.state),
+ cc(other.cc),
+ cross_road(other.cross_road),
+ addr(other.addr),
+ country(other.country),
+ phone_nr(other.phone_nr),
+ phone_nr2(other.phone_nr2),
+ fax_nr(other.fax_nr),
+ postal_code(other.postal_code),
+ email(other.email),
+ ilinks(other.ilinks)
{
- garmin_fs_t* gmsd = (garmin_fs_t*) fs;
-
- if (gmsd->addr) {
- gmsd->addr = cet_convert_string(gmsd->addr);
- }
- if (gmsd->cc) {
- gmsd->cc = cet_convert_string(gmsd->cc);
- }
- if (gmsd->city) {
- gmsd->city = cet_convert_string(gmsd->city);
- }
- if (gmsd->country) {
- gmsd->country = cet_convert_string(gmsd->country);
- }
- if (gmsd->cross_road) {
- gmsd->cross_road = cet_convert_string(gmsd->cross_road);
- }
- if (gmsd->facility) {
- gmsd->facility = cet_convert_string(gmsd->facility);
- }
- if (gmsd->phone_nr) {
- gmsd->phone_nr = cet_convert_string(gmsd->phone_nr);
- }
- if (gmsd->phone_nr2) {
- gmsd->phone_nr2 = cet_convert_string(gmsd->phone_nr2);
- }
- if (gmsd->fax_nr) {
- gmsd->fax_nr = cet_convert_string(gmsd->fax_nr);
- }
- if (gmsd->email) {
- gmsd->email = cet_convert_string(gmsd->email);
- }
- if (gmsd->postal_code) {
- gmsd->postal_code = cet_convert_string(gmsd->postal_code);
- }
- if (gmsd->state) {
- gmsd->state = cet_convert_string(gmsd->state);
+ /* do not deep copy interlinks, only increment the reference counter */
+ if (ilinks != nullptr) {
+ ilinks->ref_count++;
}
+
+#ifdef GMSD_EXPERIMENTAL
+ memcopy(subclass, other.subclass, sizeof(subclass));
+#endif
}
/* GPX - out */
garmin_fs_xml_fprint(const Waypoint* waypt,
QXmlStreamWriter* writer)
{
- garmin_fs_t* gmsd = GMSD_FIND(waypt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(waypt);
if (gmsd == nullptr) {
return;
}
/* Find out if there is at least one field set */
- const char* addr = GMSD_GET(addr, "");
- if (! *addr) {
- addr = GMSD_GET(city, "");
+ QString addr = garmin_fs_t::get_addr(gmsd, "");
+ if (addr.isEmpty()) {
+ addr = garmin_fs_t::get_city(gmsd, "");
}
- if (! *addr) {
- addr = GMSD_GET(country, "");
+ if (addr.isEmpty()) {
+ addr = garmin_fs_t::get_country(gmsd, "");
}
- if (! *addr) {
- addr = GMSD_GET(postal_code, "");
+ if (addr.isEmpty()) {
+ addr = garmin_fs_t::get_postal_code(gmsd, "");
}
- if (! *addr) {
- addr = GMSD_GET(state, "");
+ if (addr.isEmpty()) {
+ addr = garmin_fs_t::get_state(gmsd, "");
}
- const char* phone = GMSD_GET(phone_nr, "");
+ QString phone = garmin_fs_t::get_phone_nr(gmsd, "");
- if (*addr || *phone ||
+ if (!addr.isEmpty() || !phone.isEmpty() ||
(gmsd->flags.category && gmsd->category) ||
WAYPT_HAS(waypt, depth) ||
WAYPT_HAS(waypt, proximity) ||
}
writer->writeEndElement(); // gpxx:Categories
}
- if (*addr) {
- char* str;
+ if (!addr.isEmpty()) {
+ QString str;
writer->writeStartElement(QStringLiteral("gpxx:Address"));
- if ((str = GMSD_GET(addr, NULL))) {
+ if (!(str = garmin_fs_t::get_addr(gmsd, nullptr)).isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:StreetAddress"), str);
}
- if ((str = GMSD_GET(city, NULL))) {
+ if (!(str = garmin_fs_t::get_city(gmsd, nullptr)).isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:City"), str);
}
- if ((str = GMSD_GET(state, NULL))) {
+ if (!(str = garmin_fs_t::get_state(gmsd, nullptr)).isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:State"), str);
}
- if ((str = GMSD_GET(country, NULL))) {
+ if (!(str = garmin_fs_t::get_country(gmsd, nullptr)).isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:Country"), str);
}
- if ((str = GMSD_GET(postal_code, NULL))) {
+ if (!(str = garmin_fs_t::get_postal_code(gmsd, nullptr)).isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:PostalCode"), str);
}
writer->writeEndElement(); // /gpxx::Address
}
- if (*phone) {
+ if (!phone.isEmpty()) {
writer->writeTextElement(QStringLiteral("gpxx:PhoneNumber"), phone);
}
}
void
-garmin_fs_xml_convert(const int base_tag, int tag, const QString& Qcdatastr, Waypoint* waypt)
+garmin_fs_xml_convert(const int base_tag, int tag, const QString& qstr, Waypoint* waypt)
{
// FIXME: eliminate C string copy/use here:
- const char *cdatastr = xstrdup(Qcdatastr);
- garmin_fs_t* gmsd = GMSD_FIND(waypt);
+ const char *cdatastr = xstrdup(qstr);
+ garmin_fs_t* gmsd = garmin_fs_t::find(waypt);
if (gmsd == nullptr) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&waypt->fs, (format_specific_data*) gmsd);
break;
case 4:
if (case_ignore_strcmp(cdatastr, "SymbolOnly") == 0) {
- GMSD_SET(display, gt_display_mode_symbol);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol);
} else if (case_ignore_strcmp(cdatastr, "SymbolAndDescription") == 0) {
- GMSD_SET(display, gt_display_mode_symbol_and_comment);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_comment);
} else {
- GMSD_SET(display, gt_display_mode_symbol_and_name);
+ garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_name);
}
break;
case 6:
}
break;
case 7:
- GMSD_SETSTR(addr, cdatastr);
+ garmin_fs_t::set_addr(gmsd, cdatastr);
break;
case 8:
- GMSD_SETSTR(city, cdatastr);
+ garmin_fs_t::set_city(gmsd, cdatastr);
break;
case 9:
- GMSD_SETSTR(state, cdatastr);
+ garmin_fs_t::set_state(gmsd, cdatastr);
break;
case 10:
- GMSD_SETSTR(country, cdatastr);
+ garmin_fs_t::set_country(gmsd, cdatastr);
break;
case 11:
- GMSD_SETSTR(postal_code, cdatastr);
+ garmin_fs_t::set_postal_code(gmsd, cdatastr);
break;
case 12:
- GMSD_SETSTR(phone_nr, cdatastr);
+ garmin_fs_t::set_phone_nr(gmsd, cdatastr);
break;
}
xfree(cdatastr);
return 0;
}
- garmin_fs_t* gmsd = GMSD_FIND(waypt);
- cat = cat | (GMSD_GET(category, 0));
+ garmin_fs_t* gmsd = garmin_fs_t::find(waypt);
+ cat = cat | (garmin_fs_t::get_category(gmsd, 0));
if (gmsd == nullptr) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&waypt->fs, (format_specific_data*) gmsd);
}
- GMSD_SET(category, cat);
+ garmin_fs_t::set_category(gmsd, cat);
return 1;
}
/* nothing happens until gmsd is allocated some lines above */
/* !!! class needs protocol specific conversion !!! (ToDo)
- GMSD_SET(wpt_class, way[i]->wpt_class);
+ garmin_fs_t::set_wpt_class(gmsd, way[i]->wpt_class);
*/
/* flagged data fields */
- GMSD_SET(display, gt_switch_display_mode_value(way->dspl, gps_waypt_type, 1));
+ garmin_fs_t::set_display(gmsd, gt_switch_display_mode_value(way->dspl, gps_waypt_type, 1));
if (way->category != 0) {
- GMSD_SET(category, way->category);
+ garmin_fs_t::set_category(gmsd, way->category);
}
if (way->dst < 1.0e25f) {
WAYPT_SET(wpt, proximity, way->dst);
if (way->dpth < 1.0e25f) {
WAYPT_SET(wpt, depth, way->dpth);
}
- GMSD_SETNSTR(cc, way->cc, sizeof(way->cc));
- GMSD_SETNSTR(state, way->state, sizeof(way->state));
- GMSD_SETSTR(city, way->city);
- GMSD_SETSTR(facility, way->facility);
- GMSD_SETSTR(cross_road, way->cross_road);
- GMSD_SETSTR(addr, way->addr);
+ // These use STRTOUNICODE which uses gobal_opts.codec.
+ garmin_fs_t::set_cc(gmsd, STRTOUNICODE(QByteArray(way->cc, sizeof(way->cc)).constData()));
+ garmin_fs_t::set_city(gmsd, STRTOUNICODE(QByteArray(way->city, sizeof(way->city)).constData()));
+ garmin_fs_t::set_state(gmsd, STRTOUNICODE(QByteArray(way->state, sizeof(way->state)).constData()));
+ garmin_fs_t::set_facility(gmsd, STRTOUNICODE(QByteArray(way->facility, sizeof(way->facility)).constData()));
+ garmin_fs_t::set_cross_road(gmsd, STRTOUNICODE(QByteArray(way->cross_road, sizeof(way->cross_road)).constData()));
+ garmin_fs_t::set_addr(gmsd, STRTOUNICODE(QByteArray(way->addr, sizeof(way->addr)).constData()));
}
void
garmin_fs_garmin_before_write(const Waypoint* wpt, GPS_PWay way, const int protoid)
{
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
(void)protoid; // unused for now.
}
/* ToDo: protocol specific conversion of class
- way[i]->wpt_class = GMSD_GET(wpt_class, way[i]->wpt_class);
+ way[i]->wpt_class = garmin_fs_t::get_wpt_class(gmsd, way[i]->wpt_class);
*/
way->dspl = gt_switch_display_mode_value(
- GMSD_GET(display, way->dspl), gps_waypt_type, 0);
- way->category = GMSD_GET(category, way->category);
+ garmin_fs_t::get_display(gmsd, way->dspl), gps_waypt_type, 0);
+ way->category = garmin_fs_t::get_category(gmsd, way->category);
way->dpth = WAYPT_GET(wpt, depth, way->dpth);
way->dst = WAYPT_GET(wpt, proximity, way->dpth);
way->temperature = WAYPT_GET(wpt, temperature, way->temperature);
- GMSD_GETNSTR(cc, way->cc, sizeof(way->cc));
- GMSD_GETNSTR(city, way->city, sizeof(way->city));
- GMSD_GETNSTR(state, way->state, sizeof(way->state));
- GMSD_GETNSTR(facility, way->facility, sizeof(way->facility));
- GMSD_GETNSTR(cross_road, way->cross_road, sizeof(way->cross_road));
- GMSD_GETNSTR(addr, way->addr, sizeof(way->addr));
+ // These use STRFROMUNICODE which uses gobal_opts.codec.
+ strncpy(way->cc, STRFROMUNICODE(garmin_fs_t::get_cc(gmsd, nullptr)), sizeof(way->cc));
+ strncpy(way->city, STRFROMUNICODE(garmin_fs_t::get_city(gmsd, nullptr)), sizeof(way->city));
+ strncpy(way->state, STRFROMUNICODE(garmin_fs_t::get_state(gmsd, nullptr)), sizeof(way->state));
+ strncpy(way->facility, STRFROMUNICODE(garmin_fs_t::get_facility(gmsd, nullptr)), sizeof(way->facility));
+ strncpy(way->cross_road, STRFROMUNICODE(garmin_fs_t::get_cross_road(gmsd, nullptr)), sizeof(way->cross_road));
+ strncpy(way->addr, STRFROMUNICODE(garmin_fs_t::get_addr(gmsd, nullptr)), sizeof(way->addr));
}
};
*/
-/* macros */
-
-#define GMSD_FIND(a) (garmin_fs_t *) fs_chain_find((a)->fs, FS_GMSD)
-#define GMSD_HAS(a) (gmsd && gmsd->flags.a)
-
-/* GMSD_GET(a,b): a = any gmsd field, b = default value */
-#define GMSD_GET(a,b) ((gmsd) && (gmsd->flags.a)) ? (gmsd->a) : (b)
-
-/* GMSD_SET(a,b): a = numeric gmsd field, b = numeric source */
-#define GMSD_SET(a,b) if (gmsd) {gmsd->a = (b); gmsd->flags.a = 1; }
-
-/* GMSD_UNSET(a): a = gmsd field */
-#define GMSD_UNSET(a) if (gmsd) { gmsd->flags.a = 0; }
-
-/* GMSD_SETSTR(a,b): a = gmsd field, b = null terminated source */
-#define GMSD_SETSTR(a,b) if (gmsd && (b) && (b)[0]) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; }
-#define GMSD_SETQSTR(a,b) if (gmsd) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; }
-#define GMSD_SETSTRQ(a,b) if (gmsd && !b.isEmpty()) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; }
-
-/* GMSD_SETNSTR(a,b,c): a = gmsd field, b = source, c = sizeof(source) */
-#define GMSD_SETNSTR(a,b,c) if (gmsd && (b) && (b)[0]) { gmsd->a = xstrndup((b),(c)); gmsd->flags.a = 1; }
-
-/* GMSD_GETNSTR(a,b,c): a = gmsd field, b = target, c = sizeof(target) */
-#define GMSD_GETNSTR(a,b,c) if (gmsd && gmsd->flags.a) strncpy((b),gmsd->a,(c))
-
struct garmin_ilink_t {
int ref_count;
double lat, lon, alt;
};
struct garmin_fs_flags_t {
+public:
+ garmin_fs_flags_t() :
+ icon(0),
+ wpt_class(0),
+ display(0),
+ category(0),
+ city(0),
+ state(0),
+ facility(0),
+ cc(0),
+ cross_road(0),
+ addr(0),
+ country(0),
+ phone_nr(0),
+ phone_nr2(0),
+ fax_nr(0),
+ postal_code(0),
+ email(0)
+#ifdef GMSD_EXPERIMENTAL
+ , subclass(0)
+#endif
+ {}
+
unsigned int icon:1;
unsigned int wpt_class:1;
unsigned int display:1;
#endif
};
-struct garmin_fs_t {
+class garmin_fs_t {
+public:
format_specific_data fs;
garmin_fs_flags_t flags;
- int protocol; /* ... used by device (-1 is MapSource) */
-
- int32_t icon;
- int wpt_class;
- int32_t display;
- int16_t category;
- char* city; /* city name */
- char* facility; /* facility name */
- char* state; /* state */
- char* cc; /* country code */
- char* cross_road; /* Intersection road label */
- char* addr; /* address + number */
- char* country; /* country */
- char* phone_nr; /* phone number */
- char* phone_nr2; /* phone number (2) */
- char* fax_nr; /* fax number */
- char* postal_code; /* postal code */
- char* email; /* email address */
- garmin_ilink_t* ilinks;
+ int protocol{0}; /* ... used by device (-1 is MapSource) */
+
+ int32_t icon{0};
+ int wpt_class{0};
+ int32_t display{0};
+ int16_t category{0};
+ QString city; /* city name */
+ QString facility; /* facility name */
+ QString state; /* state */
+ QString cc; /* country code */
+ QString cross_road; /* Intersection road label */
+ QString addr; /* address + number */
+ QString country; /* country */
+ QString phone_nr; /* phone number */
+ QString phone_nr2; /* phone number (2) */
+ QString fax_nr; /* fax number */
+ QString postal_code; /* postal code */
+ QString email; /* email address */
+ garmin_ilink_t* ilinks{nullptr};
#ifdef GMSD_EXPERIMENTAL
- char subclass[22];
+ char subclass[22]{};
#endif
+
+public:
+ garmin_fs_t() = default;
+ ~garmin_fs_t();
+ garmin_fs_t(const garmin_fs_t& other);
+ garmin_fs_t& operator=(const garmin_fs_t& rhs) = delete; /* not implemented */
+ garmin_fs_t(garmin_fs_t&&) = delete; /* not implemented */
+ garmin_fs_t& operator=(garmin_fs_t&&) = delete; /* not implemented */
+
+ static garmin_fs_t* find(const Waypoint* wpt) {
+ return (garmin_fs_t*) fs_chain_find(wpt->fs, FS_GMSD);
+ }
+
+#define GEN_GMSD_METHODS(field) \
+ static bool has_##field(const garmin_fs_t* gmsd) \
+ { \
+ return gmsd && gmsd->flags.field; \
+ } \
+ static decltype(field) get_##field(const garmin_fs_t* gmsd, decltype(field) p) \
+ { \
+ return (gmsd && gmsd->flags.field)? gmsd->field : p; \
+ } \
+ static void set_##field(garmin_fs_t* gmsd, decltype(field) p) \
+ { \
+ if (gmsd) { \
+ gmsd->field = p; \
+ gmsd->flags.field = 1; \
+ } \
+ } \
+ static void unset_##field(garmin_fs_t* gmsd) \
+ { \
+ if (gmsd) { \
+ gmsd->flags.field = 0; \
+ } \
+ }
+
+ GEN_GMSD_METHODS(icon)
+ GEN_GMSD_METHODS(wpt_class)
+ GEN_GMSD_METHODS(display)
+ GEN_GMSD_METHODS(category)
+
+#undef GEN_GMSD_METHODS
+
+#define GEN_GMSD_STR_METHODS(field) \
+ static bool has_##field(const garmin_fs_t* gmsd) \
+ { \
+ return gmsd && gmsd->flags.field; \
+ } \
+ static QString get_##field(const garmin_fs_t* gmsd, const QString& p) \
+ { \
+ return (gmsd && gmsd->flags.field)? gmsd->field : p; \
+ } \
+ static void set_##field(garmin_fs_t* gmsd, const char* p) \
+ { \
+ if (gmsd && p && *p) { \
+ gmsd->field = p; \
+ gmsd->flags.field = 1; \
+ } \
+ } \
+ static void set_##field(garmin_fs_t* gmsd, const QString& p) \
+ { \
+ if (gmsd && !p.isEmpty()) { \
+ gmsd->field = p; \
+ gmsd->flags.field = 1; \
+ } \
+ } \
+ static void unset_##field(garmin_fs_t* gmsd) \
+ { \
+ if (gmsd) { \
+ gmsd->flags.field = 0; \
+ } \
+ }
+
+ GEN_GMSD_STR_METHODS(city)
+ GEN_GMSD_STR_METHODS(facility)
+ GEN_GMSD_STR_METHODS(state)
+ GEN_GMSD_STR_METHODS(cc)
+ GEN_GMSD_STR_METHODS(cross_road)
+ GEN_GMSD_STR_METHODS(addr)
+ GEN_GMSD_STR_METHODS(country)
+ GEN_GMSD_STR_METHODS(phone_nr)
+ GEN_GMSD_STR_METHODS(phone_nr2)
+ GEN_GMSD_STR_METHODS(fax_nr)
+ GEN_GMSD_STR_METHODS(postal_code)
+ GEN_GMSD_STR_METHODS(email)
+
+#undef GEN_GMSD_STR_METHODS
};
using garmin_fs_p = garmin_fs_t*;
char* garmin_fs_xstrdup(const char* src, size_t size);
/* for GPX */
-void garmin_fs_xml_convert(int base_tag, int tag, const QString& cdatastr, Waypoint* waypt);
+void garmin_fs_xml_convert(int base_tag, int tag, const QString& qstr, Waypoint* waypt);
class QXmlStreamWriter;
void garmin_fs_xml_fprint(const Waypoint* waypt, QXmlStreamWriter*);
};
struct gpi_waypt_t {
- int sz;
- int alerts;
- short mask;
- char addr_is_dynamic;
- char* addr;
- char* city;
- char* country;
- char* phone_nr;
- char* postal_code;
- char* state;
+ int sz{0};
+ int alerts{0};
+ short mask{0};
+ QString addr;
+ QString city;
+ QString country;
+ QString phone_nr;
+ QString postal_code;
+ QString state;
};
static gbfile* fin, *fout;
static garmin_fs_t*
gpi_gmsd_init(Waypoint* wpt)
{
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (wpt == nullptr) {
fatal(MYNAME ": Error in file structure.\n");
}
double speed;
short mask;
QString str;
- char* cstr;
garmin_fs_t* gmsd;
int sz = gbfgetint32(fin);
#ifdef GPI_DBG
dbginfo("GPI Address field mask: %d (0x%02x)\n", mask, mask);
#endif
- if ((mask & GPI_ADDR_CITY) && (cstr = gpi_read_string_old("City"))) {
+ if ((mask & GPI_ADDR_CITY) && !(str = gpi_read_string("City")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(city, cstr);
+ garmin_fs_t::set_city(gmsd, str);
}
- if ((mask & GPI_ADDR_COUNTRY) && (cstr = gpi_read_string_old("Country"))) {
+ if ((mask & GPI_ADDR_COUNTRY) && !(str = gpi_read_string("Country")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(country, cstr);
+ garmin_fs_t::set_country(gmsd, str);
}
- if ((mask & GPI_ADDR_STATE) && (cstr = gpi_read_string_old("State"))) {
+ if ((mask & GPI_ADDR_STATE) && !(str = gpi_read_string("State")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(state, cstr);
+ garmin_fs_t::set_state(gmsd, str);
}
- if ((mask & GPI_ADDR_POSTAL_CODE) && (cstr = gpi_read_string_old("Postal code"))) {
+ if ((mask & GPI_ADDR_POSTAL_CODE) && !(str = gpi_read_string("Postal code")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(postal_code, cstr);
+ garmin_fs_t::set_postal_code(gmsd, str);
}
- if ((mask & GPI_ADDR_ADDR) && (cstr = gpi_read_string_old("Street address"))) {
+ if ((mask & GPI_ADDR_ADDR) && !(str = gpi_read_string("Street address")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(addr, cstr);
+ garmin_fs_t::set_addr(gmsd, str);
}
break;
case 0xc:
mask = gbfgetint16(fin);
- if ((mask & 1) && (cstr = gpi_read_string_old("Phone"))) {
+ if ((mask & 1) && !(str = gpi_read_string("Phone")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(phone_nr, cstr);
+ garmin_fs_t::set_phone_nr(gmsd, str);
}
- if ((mask & 2) && (cstr = gpi_read_string_old("Phone2"))) {
+ if ((mask & 2) && !(str = gpi_read_string("Phone2")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(phone_nr2, cstr);
+ garmin_fs_t::set_phone_nr2(gmsd, str);
}
- if ((mask & 4) && (cstr = gpi_read_string_old("Fax"))) {
+ if ((mask & 4) && !(str = gpi_read_string("Fax")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(fax_nr, cstr);
+ garmin_fs_t::set_fax_nr(gmsd, str);
}
- if ((mask & 8) && (cstr = gpi_read_string_old("Email"))) {
+ if ((mask & 8) && !(str = gpi_read_string("Email")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(email, cstr);
+ garmin_fs_t::set_email(gmsd, str);
}
if ((mask & 0x10) && (str = gpi_read_string("Link"), !str.isEmpty())) {
waypt_add_url(wpt, str, str);
#ifdef GPI_DBG
dbginfo("GPI Phone field mask: %d (0x%02x)\n", mask, mask);
#endif
- if ((mask & 1) && (cstr = gpi_read_string_old("Phone"))) {
+ if ((mask & 1) && !(str = gpi_read_string("Phone")).isEmpty()) {
gmsd = gpi_gmsd_init(wpt);
- GMSD_SET(phone_nr, cstr);
+ garmin_fs_t::set_phone_nr(gmsd, str);
}
break;
if (wpt->extra_data) {
gpi_waypt_t* dt = (gpi_waypt_t*) wpt->extra_data;
- if (dt->addr_is_dynamic) {
- xfree(dt->addr);
- }
- xfree(dt);
+ delete dt;
}
delete wpt;
}
res += 10; /* tag(4) */
}
- gpi_waypt_t* dt = (gpi_waypt_t*) xcalloc(1, sizeof(*dt));
+ gpi_waypt_t* dt = new gpi_waypt_t;
wpt->extra_data = dt;
if (alerts) {
}
}
- QString str = QString();
+ QString str;
if (opt_descr) {
if (!wpt->description.isEmpty()) {
str = wpt->description;
if (!str.isEmpty()) {
- dt->addr_is_dynamic = 1;
- dt->addr = xstrdup(str);
+ dt->addr = str;
dt->mask |= GPI_ADDR_ADDR;
- dt->sz += (8 + strlen(dt->addr));
+ dt->sz += (8 + strlen(STRFROMUNICODE(dt->addr)));
}
- if ((gmsd = GMSD_FIND(wpt))) {
- if ((dt->mask == 0) && ((dt->addr = GMSD_GET(addr, NULL)))) {
+ if ((gmsd = garmin_fs_t::find(wpt))) {
+ if ((dt->mask == 0) && !(dt->addr = garmin_fs_t::get_addr(gmsd, nullptr)).isEmpty()) {
dt->mask |= GPI_ADDR_ADDR;
- dt->sz += (8 + strlen(dt->addr));
+ dt->sz += (8 + strlen(STRFROMUNICODE(dt->addr)));
}
- if ((dt->city = GMSD_GET(city, NULL))) {
+ if (!(dt->city = garmin_fs_t::get_city(gmsd, nullptr)).isEmpty()) {
dt->mask |= GPI_ADDR_CITY;
- dt->sz += (8 + strlen(dt->city));
+ dt->sz += (8 + strlen(STRFROMUNICODE(dt->city)));
}
- if ((dt->country = GMSD_GET(country, NULL))) {
+ if (!(dt->country = garmin_fs_t::get_country(gmsd, nullptr)).isEmpty()) {
dt->mask |= GPI_ADDR_COUNTRY;
- dt->sz += (8 + strlen(dt->country));
+ dt->sz += (8 + strlen(STRFROMUNICODE(dt->country)));
}
- if ((dt->state = GMSD_GET(state, NULL))) {
+ if (!(dt->state = garmin_fs_t::get_state(gmsd, nullptr)).isEmpty()) {
dt->mask |= GPI_ADDR_STATE;
- dt->sz += (8 + strlen(dt->state));
+ dt->sz += (8 + strlen(STRFROMUNICODE(dt->state)));
}
- if ((dt->postal_code = GMSD_GET(postal_code, NULL))) {
+ if (!(dt->postal_code = garmin_fs_t::get_postal_code(gmsd, nullptr)).isEmpty()) {
dt->mask |= GPI_ADDR_POSTAL_CODE;
- dt->sz += (2 + strlen(dt->postal_code)); /* short form */
+ dt->sz += (2 + strlen(STRFROMUNICODE(dt->postal_code))); /* short form */
}
- if ((dt->phone_nr = GMSD_GET(phone_nr, NULL))) {
- res += (12 + 4 + strlen(dt->phone_nr));
+ if (!(dt->phone_nr = garmin_fs_t::get_phone_nr(gmsd, nullptr)).isEmpty()) {
+ res += (12 + 4 + strlen(STRFROMUNICODE(dt->phone_nr)));
}
}
if (dt->mask) {
if (dt->sz) {
s0 += (12 + dt->sz); /* address part */
}
- if (dt->phone_nr) {
- s0 += (12 + 4 + strlen(dt->phone_nr));
+ if (!dt->phone_nr.isEmpty()) {
+ s0 += (12 + 4 + strlen(STRFROMUNICODE(dt->phone_nr)));
}
if (dt->alerts) {
s0 += 20; /* tag(3) */
gbfputint32(0x2, fout); /* ? always 2 ? */
gbfputint16(dt->mask, fout);
if (dt->mask & GPI_ADDR_CITY) {
- write_string(dt->city, 1);
+ write_string(STRFROMUNICODE(dt->city), 1);
}
if (dt->mask & GPI_ADDR_COUNTRY) {
- write_string(dt->country, 1);
+ write_string(STRFROMUNICODE(dt->country), 1);
}
if (dt->mask & GPI_ADDR_STATE) {
- write_string(dt->state, 1);
+ write_string(STRFROMUNICODE(dt->state), 1);
}
if (dt->mask & GPI_ADDR_POSTAL_CODE) {
- write_string(dt->postal_code, 0);
+ write_string(STRFROMUNICODE(dt->postal_code), 0);
}
if (dt->mask & GPI_ADDR_ADDR) {
- write_string(dt->addr, 1);
+ write_string(STRFROMUNICODE(dt->addr), 1);
}
}
- if (dt->phone_nr) {
+ if (!dt->phone_nr.isEmpty()) {
gbfputint32(0x8000c, fout);
- gbfputint32(strlen(dt->phone_nr) + 2 + 2, fout);
+ gbfputint32(strlen(STRFROMUNICODE(dt->phone_nr)) + 2 + 2, fout);
gbfputint32(0x2, fout); /* ? always 2 ? */
gbfputint16(1, fout); /* mask */
- write_string(dt->phone_nr, 0);
+ write_string(STRFROMUNICODE(dt->phone_nr), 0);
}
}
static void
enum_waypt_cb(const Waypoint* wpt)
{
- garmin_fs_p gmsd = GMSD_FIND(wpt);
- int wpt_class = GMSD_GET(wpt_class, 0);
+ garmin_fs_p gmsd = garmin_fs_t::find(wpt);
+ int wpt_class = garmin_fs_t::get_wpt_class(gmsd, 0);
if (wpt_class < 0x80) {
if (gtxt_flags.enum_waypoints) { /* enumerate only */
waypoints++;
{
const char* wpt_type;
- garmin_fs_p gmsd = GMSD_FIND(wpt);
+ garmin_fs_p gmsd = garmin_fs_t::find(wpt);
- int i = GMSD_GET(display, 0);
+ int i = garmin_fs_t::get_display(gmsd, 0);
if (i > GT_DISPLAY_MODE_MAX) {
i = 0;
}
const char* dspl_mode = gt_display_mode_names[i];
- unsigned char wpt_class = GMSD_GET(wpt_class, 0);
+ unsigned char wpt_class = garmin_fs_t::get_wpt_class(gmsd, 0);
if (wpt_class <= gt_waypt_class_map_line) {
wpt_type = gt_waypt_class_names[wpt_class];
} else {
*fout << "Unknown\t"; /* Color is fixed: Unknown */
- int icon = GMSD_GET(icon, -1);
+ int icon = garmin_fs_t::get_icon(gmsd, -1);
if (icon == -1) {
icon = gt_find_icon_number_from_desc(wpt->icon_descr, GDB);
}
print_string("%s\t", gt_find_desc_from_icon_number(icon, GDB));
- print_string("%s\t", GMSD_GET(facility, ""));
- print_string("%s\t", GMSD_GET(city, ""));
- print_string("%s\t", GMSD_GET(state, ""));
- const char* country = gt_get_icao_country(GMSD_GET(cc, ""));
+ print_string("%s\t", garmin_fs_t::get_facility(gmsd, ""));
+ print_string("%s\t", garmin_fs_t::get_city(gmsd, ""));
+ print_string("%s\t", garmin_fs_t::get_state(gmsd, ""));
+ const char* country = gt_get_icao_country(garmin_fs_t::get_cc(gmsd, ""));
print_string("%s\t", (country != nullptr) ? country : "");
print_date_and_time(wpt->GetCreationTime().toTime_t(), 0);
if (wpt->HasUrlLink()) {
} else {
print_string("%s\t", "");
}
- print_categories(GMSD_GET(category, 0));
+ print_categories(garmin_fs_t::get_category(gmsd, 0));
*fout << "\r\n";
}
case 3:
for (i = 0; i <= gt_waypt_class_map_line; i++) {
if (case_ignore_strcmp(str, gt_waypt_class_names[i]) == 0) {
- GMSD_SET(wpt_class, i);
+ garmin_fs_t::set_wpt_class(gmsd, i);
break;
}
}
break;
case 9:
if (parse_display(str, &i)) {
- GMSD_SET(display, i);
+ garmin_fs_t::set_display(gmsd, i);
}
break;
case 10:
break; /* skip color */
case 11:
i = gt_find_icon_number_from_desc(str, GDB);
- GMSD_SET(icon, i);
+ garmin_fs_t::set_icon(gmsd, i);
wpt->icon_descr = gt_find_desc_from_icon_number(i, GDB);
break;
case 12:
- GMSD_SETSTR(facility, str);
+ garmin_fs_t::set_facility(gmsd, str);
break;
case 13:
- GMSD_SETSTR(city, str);
+ garmin_fs_t::set_city(gmsd, str);
break;
case 14:
- GMSD_SETSTR(state, str);
+ garmin_fs_t::set_state(gmsd, str);
break;
case 15:
- GMSD_SETSTR(country, str);
- GMSD_SETSTR(cc, gt_get_icao_cc(str, wpt->shortname));
+ garmin_fs_t::set_country(gmsd, str);
+ garmin_fs_t::set_cc(gmsd, gt_get_icao_cc(str, wpt->shortname));
break;
case 16: {
time_t ct;
}
break;
case 18:
- GMSD_SET(category, parse_categories(str));
+ garmin_fs_t::set_category(gmsd, parse_categories(str));
break;
default:
break;
read_waypoint(gt_waypt_classes_e* waypt_class_out)
{
char buf[128]; /* used for temporary stuff */
- QByteArray ba;
int display, icon;
gt_waypt_classes_e wpt_class;
int i;
Waypoint* res;
garmin_fs_t* gmsd;
- char* str;
+ QString str;
#ifdef GMSD_EXPERIMENTAL
char subclass[22];
#endif
fs_chain_add(&res->fs, (format_specific_data*) gmsd);
res->shortname = fread_cstr();
wpt_class = (gt_waypt_classes_e) FREAD_i32;
- GMSD_SET(wpt_class, wpt_class);
+ garmin_fs_t::set_wpt_class(gmsd, wpt_class);
if (wpt_class != 0) {
waypth_ct++;
}
- ba = FREAD_STR(); /* Country code */
- GMSD_SETSTR(cc, ba.constData());
+ garmin_fs_t::set_cc(gmsd, fread_cstr());
#ifdef GMSD_EXPERIMENTAL
FREAD(subclass, sizeof(subclass));
display = gt_display_mode_symbol_and_name;
break;
}
- GMSD_SET(display, display);
+ garmin_fs_t::set_display(gmsd, display);
FREAD_i32; /* color !not implemented! */
icon = FREAD_i32;
- GMSD_SET(icon, icon); /* icon */
- ba = FREAD_STR(); /* city */
- GMSD_SETSTR(city, ba.constData());
- ba = FREAD_STR(); /* state */
- GMSD_SETSTR(state, ba.constData());
- ba = FREAD_STR(); /* facility */
- GMSD_SETSTR(facility, ba.constData());
+ garmin_fs_t::set_icon(gmsd, icon);
+ garmin_fs_t::set_city(gmsd, fread_cstr());
+ garmin_fs_t::set_state(gmsd, fread_cstr());
+ garmin_fs_t::set_facility(gmsd, fread_cstr());
FREAD(buf, 1);
waypt_flag = 0;
- ba = FREAD_STR(); /* street address */
- GMSD_SETSTR(addr, ba.constData());
+ garmin_fs_t::set_addr(gmsd, fread_cstr());
FREAD(buf, 5); /* instruction depended */
res->description = FREAD_CSTR_AS_QSTR; /* instruction */
#endif
i = FREAD_i16;
if (i != 0) {
- GMSD_SET(category, i);
+ garmin_fs_t::set_category(gmsd, i);
}
#if GDB_DEBUG
DBG(GDB_DBG_WPTe, i)
/* VERSION DEPENDENT CODE */
if (gdb_ver >= GDB_VER_3) {
if (FREAD_i32 == 1) {
- ba = FREAD_STR(); /* phone number */
- GMSD_SETSTR(phone_nr, ba.constData());
+ garmin_fs_t::set_phone_nr(gmsd, fread_cstr());
(void) FREAD_STR(); /* ?? fax / mobile ?? */
}
- ba = FREAD_STR(); /* country */
- GMSD_SETSTR(country, ba.constData());
- ba = FREAD_STR(); /* postal code */
- GMSD_SETSTR(postal_code, ba.constData());
+ garmin_fs_t::set_country(gmsd, fread_cstr());
+ garmin_fs_t::set_postal_code(gmsd, fread_cstr());
}
res->icon_descr = gt_find_desc_from_icon_number(icon, GDB);
printf(MYNAME "-wpt \"%s\" (%d): icon = \"%s\" (MapSource symbol %d)\n",
qPrintable(res->shortname), wpt_class, qPrintable(res->icon_descr), icon);
#endif
- if ((str = GMSD_GET(cc, NULL))) {
- if (! GMSD_HAS(country)) {
- GMSD_SETSTR(country, gt_get_icao_country(str));
+ if (!(str = garmin_fs_t::get_cc(gmsd, nullptr)).isEmpty()) {
+ if (! (garmin_fs_t::has_country(gmsd))) {
+ garmin_fs_t::set_country(gmsd, gt_get_icao_country(str));
}
}
if (gdb_roadbook && (wpt_class > gt_waypt_class_map_point) && !res->description.isEmpty()) {
wpt_class = gt_waypt_class_user_waypoint;
- GMSD_SET(wpt_class, wpt_class);
+ garmin_fs_t::set_wpt_class(gmsd, wpt_class);
#ifdef GMSD_EXPERIMENTAL
- GMSD_UNSET(subclass);
+ garmin_fs_t::unset_subclass(gmsd);
#endif
}
*waypt_class_out = wpt_class;
#endif
wpt = gdb_add_route_waypt(rte, wpt, wpt_class);
if (wpt != nullptr) {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (gmsd == nullptr) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&wpt->fs, (format_specific_data*) gmsd);
}
- GMSD_SET(wpt_class, wpt_class);
+ garmin_fs_t::set_wpt_class(gmsd, wpt_class);
gmsd->ilinks = il_root;
il_root = nullptr;
}
FWRITE_CSTR(shortname); /* unique (!!!) shortname */
FWRITE_i32(wpt_class); /* waypoint class */
- FWRITE_CSTR(GMSD_GET(cc, "")); /* country code */
+ FWRITE_CSTR(garmin_fs_t::get_cc(gmsd, "")); /* country code */
if (wpt_class != 0) {
waypth_ct++;
FWRITE_i32(display); /* display */
FWRITE_i32(0); /* color */
FWRITE_i32(icon); /* icon */
- FWRITE_CSTR(GMSD_GET(city, "")); /* city */
- FWRITE_CSTR(GMSD_GET(state, "")); /* state */
- FWRITE_CSTR(GMSD_GET(facility, "")); /* facility */
+ FWRITE_CSTR(garmin_fs_t::get_city(gmsd, "")); /* city */
+ FWRITE_CSTR(garmin_fs_t::get_state(gmsd, "")); /* state */
+ FWRITE_CSTR(garmin_fs_t::get_facility(gmsd, "")); /* facility */
FWRITE_C(0); /* unknown */
FWRITE_DBL(WAYPT_GET(wpt, depth, unknown_alt), unknown_alt); /* depth */
QString str;
if (wpt_class < gt_waypt_class_map_point) { /* street address */
- str = GMSD_GET(addr, "");
+ str = garmin_fs_t::get_addr(gmsd, "");
} else {
str = "";
}
}
}
- FWRITE_i16(GMSD_GET(category, gdb_category));
+ FWRITE_i16(garmin_fs_t::get_category(gmsd, gdb_category));
FWRITE_DBL(WAYPT_GET(wpt, temperature, 0), 0);
FWRITE_TIME(wpt->GetCreationTime().toTime_t());
/* VERSION DEPENDENT CODE */
if (gdb_ver >= GDB_VER_3) {
- const char* str = GMSD_GET(phone_nr, "");
- if (*str) {
+ QString str = garmin_fs_t::get_phone_nr(gmsd, "");
+ if (!str.isEmpty()) {
FWRITE_i32(1);
FWRITE_CSTR(str);
FWRITE_CSTR("");
} else {
FWRITE_i32(0);
}
- FWRITE_CSTR(GMSD_GET(country, ""));
- FWRITE_CSTR(GMSD_GET(postal_code, ""));
+ FWRITE_CSTR(garmin_fs_t::get_country(gmsd, ""));
+ FWRITE_CSTR(garmin_fs_t::get_postal_code(gmsd, ""));
}
}
fatal(MYNAME ": Sorry, that should never happen!!!\n");
}
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
/* extra_data may contain a modified shortname */
FWRITE_CSTR((wpt->extra_data) ? (char*)wpt->extra_data : wpt->shortname);
int wpt_class = wpt->wpt_flags.fmt_use; /* trick */
FWRITE_i32(wpt_class); /* waypoint class */
- FWRITE_CSTR(GMSD_GET(cc, "")); /* country */
+ FWRITE_CSTR(garmin_fs_t::get_cc(gmsd, "")); /* country */
#ifdef GMSD_EXPERIMENTAL
if (gmsd && gmsd->flags.subclass && (wpt_class >= gt_waypt_class_map_point)) {
FWRITE(gmsd->subclass, sizeof(gmsd->subclass));
fout = ftmp;
/* prepare the waypoint */
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
- int wpt_class = GMSD_GET(wpt_class, -1);
+ int wpt_class = garmin_fs_t::get_wpt_class(gmsd, -1);
if (wpt_class == -1) {
wpt_class = (route_flag) ? GDB_DEF_HIDDEN_CLASS : GDB_DEF_CLASS;
}
wpt->wpt_flags.fmt_use = wpt_class; /* trick, we need this for the route(s) */
- int icon = GMSD_GET(icon, -1);
+ int icon = garmin_fs_t::get_icon(gmsd, -1);
if (icon < 0) {
if (wpt->icon_descr.isNull()) {
icon = GDB_DEF_ICON;
}
}
- switch (GMSD_GET(display, -1)) { /* display */
+ switch (garmin_fs_t::get_display(gmsd, -1)) { /* display */
case -1:
if (wpt_class < 8) {
display = gt_gdb_display_mode_symbol_and_name;
if (!(opt_humminbirdext || opt_garminext)) {
auto* fs_gpx = (fs_xml*)fs_chain_find(waypointp->fs, FS_GPX);
- auto* gmsd = GMSD_FIND(waypointp); /* gARmIN sPECIAL dATA */
+ auto* gmsd = garmin_fs_t::find(waypointp); /* gARmIN sPECIAL dATA */
if (fs_gpx) {
if (! gmsd) {
fprint_xml_chain(fs_gpx->tag, waypointp);
fsdata->fs.type = FS_LOWRANCEUSR4;
fsdata->fs.copy = (fs_copy) lowranceusr4_copy_fsdata;
fsdata->fs.destroy = lowranceusr4_free_fsdata;
- fsdata->fs.convert = nullptr;
fsdata->uid_unit = 0;
fsdata->uid_seq_low = 0;
#endif
#include "defs.h"
-#include "cet_util.h" // for cet_convert_init, cet_convert_strings, cet_convert_deinit, cet_deregister, cet_register, cet_cs_vec_utf8
+#include "cet_util.h" // for cet_convert_init, cet_convert_deinit, cet_deregister, cet_register, cet_cs_vec_utf8
#include "csv_util.h" // for csv_linesplit
#include "filter.h" // for Filter
#include "filter_vecs.h" // for FilterVecs
ivecs->read();
ivecs->rd_deinit();
- cet_convert_strings(global_opts.charset, nullptr);
cet_convert_deinit();
did_something = true;
route_backup(&rte_head_bak);
track_backup(&trk_head_bak);
- cet_convert_strings(nullptr, global_opts.charset);
global_opts.verbose_status = saved_status;
}
ivecs->read();
ivecs->rd_deinit();
- cet_convert_strings(global_opts.charset, nullptr);
cet_convert_deinit();
if (qargs.size() == 2 && ovecs) {
cet_convert_init(ovecs->get_encode(), 1);
- cet_convert_strings(nullptr, global_opts.charset);
ovecs->wr_init(qargs.at(1));
ovecs->write();
int saved_status = global_opts.verbose_status;
global_opts.verbose_status = 0;
cet_convert_init(CET_CHARSET_ASCII, 1);
- cet_convert_strings(nullptr, global_opts.charset);
waypt_disp_all(waypt_disp);
global_opts.verbose_status = saved_status;
}
fsdata->fs.type = FS_OZI;
fsdata->fs.copy = (fs_copy) ozi_copy_fsdata;
fsdata->fs.destroy = ozi_free_fsdata;
- fsdata->fs.convert = nullptr;
/* Provide defaults via command line defaults */
fsdata->fgcolor = color_to_bbggrr(wptfgcolor);
/* rand_str always returns a valid string with len >= 0 */
-static char*
+static QString
rand_str(const int maxlen, const char* fmt)
{
int len = rand_int(maxlen) + 1;
- auto res = (char*) xmalloc(len + 1);
- res[len] = '\0';
+ QByteArray res;
+ res.resize(len);
- for (int i = 0; i < len; i++) {
+ for (int i = 0; i < len; ++i) {
int c = rand_int(26 + 26 + 10);
if (c < 26) {
c += 'a';
}
res[i] = c;
}
- if (fmt) {
- char* tmp;
- xasprintf(&tmp, fmt, res);
- xfree(res);
- return tmp;
- } else {
- return res;
- }
-}
-
-static QString
-rand_qstr(const int maxlen, const char* fmt)
-{
- char * str = rand_str(maxlen, fmt);
- QString qstr = QString(str);
- xfree(str);
- return qstr;
+ return (fmt != nullptr)?
+ QString::asprintf(fmt, res.constData()) : QString(res);
}
static void
fs_chain_add(&wpt->fs, (format_specific_data*) gmsd);
do {
- wpt->shortname = rand_qstr(8, "Wpt_%s");
+ wpt->shortname = rand_str(8, "Wpt_%s");
} while (wpt->shortname == nullptr);
wpt->latitude = rand_dbl(180.0) - 90.0;
WAYPT_SET(wpt, depth, rand_dbl(1000.0));
}
if RND(3) {
- wpt->AddUrlLink(rand_qstr(8, "http://link1.example.com/%s"));
+ wpt->AddUrlLink(rand_str(8, "http://link1.example.com/%s"));
if RND(3) {
- wpt->AddUrlLink(rand_qstr(8, "http://link2.example.com/%s"));
+ wpt->AddUrlLink(rand_str(8, "http://link2.example.com/%s"));
}
}
if RND(3) {
- wpt->icon_descr = rand_qstr(3, "Icon_%s");
+ wpt->icon_descr = rand_str(3, "Icon_%s");
}
wpt->SetCreationTime(time);
wpt->longitude = prev->longitude + rand_dbl(0.01);
}
if RND(3) {
- wpt->description = rand_qstr(16, "Des_%s");
+ wpt->description = rand_str(16, "Des_%s");
}
if RND(3) {
- wpt->notes = rand_qstr(16, "Nts_%s");
+ wpt->notes = rand_str(16, "Nts_%s");
}
if RND(3) {
- GMSD_SET(addr, rand_str(8, "Adr_%s"));
+ garmin_fs_t::set_addr(gmsd, rand_str(8, "Adr_%s"));
}
if RND(3) {
- GMSD_SET(city, rand_str(8, "Cty_%s"));
+ garmin_fs_t::set_city(gmsd, rand_str(8, "Cty_%s"));
}
if RND(3) {
- GMSD_SET(facility, rand_str(8, "Fac_%s"));
+ garmin_fs_t::set_facility(gmsd, rand_str(8, "Fac_%s"));
}
if RND(3) {
- GMSD_SET(country, rand_str(8, "Ctr_%s"));
+ garmin_fs_t::set_country(gmsd, rand_str(8, "Ctr_%s"));
}
if RND(3) {
- GMSD_SET(state, rand_str(8, "Sta_%s"));
+ garmin_fs_t::set_state(gmsd, rand_str(8, "Sta_%s"));
}
if RND(3) {
- GMSD_SET(phone_nr, rand_str(8, "Pnr_%s"));
+ garmin_fs_t::set_phone_nr(gmsd, rand_str(8, "Pnr_%s"));
}
if RND(3) {
- GMSD_SET(postal_code, rand_str(8, "Pcd_%s"));
+ garmin_fs_t::set_postal_code(gmsd, rand_str(8, "Pcd_%s"));
}
}
if (doing_trks || doing_rtes) {
head = route_head_alloc();
if (doing_trks) {
- head->rte_name = rand_qstr(8, "Trk_%s");
+ head->rte_name = rand_str(8, "Trk_%s");
track_add_head(head);
} else {
- head->rte_name = rand_qstr(8, "Rte_%s");
+ head->rte_name = rand_str(8, "Rte_%s");
route_add_head(head);
}
- head->rte_desc = rand_qstr(16, nullptr);
+ head->rte_desc = rand_str(16, nullptr);
if RND(3) {
- head->rte_urls.AddUrlLink(UrlLink(rand_qstr(8, "http://rteurl.example.com/%s")));
+ head->rte_urls.AddUrlLink(UrlLink(rand_str(8, "http://rteurl.example.com/%s")));
}
} else {
head = nullptr;
case fld_garmin_fax_nr:
case fld_garmin_email:
case fld_garmin_facility:
- gmsd = GMSD_FIND(wpt);
+ gmsd = garmin_fs_t::find(wpt);
if (! gmsd) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&wpt->fs, (format_specific_data*) gmsd);
}
switch (unicsv_fields_tab[column]) {
case fld_garmin_city:
- GMSD_SETQSTR(city, value);
+ garmin_fs_t::set_city(gmsd, value);
break;
case fld_garmin_postal_code:
- GMSD_SETQSTR(postal_code, value);
+ garmin_fs_t::set_postal_code(gmsd, value);
break;
case fld_garmin_state:
- GMSD_SETQSTR(state, value);
+ garmin_fs_t::set_state(gmsd, value);
break;
case fld_garmin_country:
- GMSD_SETQSTR(country, value);
+ garmin_fs_t::set_country(gmsd, value);
break;
case fld_garmin_addr:
- GMSD_SETQSTR(addr, value);
+ garmin_fs_t::set_addr(gmsd, value);
break;
case fld_garmin_phone_nr:
- GMSD_SETQSTR(phone_nr, value);
+ garmin_fs_t::set_phone_nr(gmsd, value);
break;
case fld_garmin_phone_nr2:
- GMSD_SETQSTR(phone_nr2, value);
+ garmin_fs_t::set_phone_nr2(gmsd, value);
break;
case fld_garmin_fax_nr:
- GMSD_SETQSTR(fax_nr, value);
+ garmin_fs_t::set_fax_nr(gmsd, value);
break;
case fld_garmin_email:
- GMSD_SETQSTR(email, value);
+ garmin_fs_t::set_email(gmsd, value);
break;
case fld_garmin_facility:
- GMSD_SETQSTR(facility, value);
+ garmin_fs_t::set_facility(gmsd, value);
break;
default:
break;
unicsv_waypt_enum_cb(const Waypoint* wpt)
{
const QString& shortname = wpt->shortname;
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (!shortname.isEmpty()) {
gb_setbit(&unicsv_outp_flags, fld_shortname);
}
if (gmsd) {
- if GMSD_HAS(addr) {
+ if (garmin_fs_t::has_addr(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_addr);
}
- if GMSD_HAS(city) {
+ if (garmin_fs_t::has_city(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_city);
}
- if GMSD_HAS(country) {
+ if (garmin_fs_t::has_country(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_country);
}
- if GMSD_HAS(phone_nr) {
+ if (garmin_fs_t::has_phone_nr(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr);
}
- if GMSD_HAS(phone_nr2) {
+ if (garmin_fs_t::has_phone_nr2(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr2);
}
- if GMSD_HAS(fax_nr) {
+ if (garmin_fs_t::has_fax_nr(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_fax_nr);
}
- if GMSD_HAS(email) {
+ if (garmin_fs_t::has_email(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_email);
}
- if GMSD_HAS(postal_code) {
+ if (garmin_fs_t::has_postal_code(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_postal_code);
}
- if GMSD_HAS(state) {
+ if (garmin_fs_t::has_state(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_state);
}
- if GMSD_HAS(facility) {
+ if (garmin_fs_t::has_facility(gmsd)) {
gb_setbit(&unicsv_outp_flags, fld_garmin_facility);
}
}
unicsv_waypt_ct++;
QString shortname = wpt->shortname;
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (unicsv_datum_idx == DATUM_WGS84) {
lat = wpt->latitude;
}
if FIELD_USED(fld_garmin_facility) {
- unicsv_print_str(GMSD_GET(facility, NULL));
+ unicsv_print_str(garmin_fs_t::get_facility(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_addr) {
- unicsv_print_str(GMSD_GET(addr, NULL));
+ unicsv_print_str(garmin_fs_t::get_addr(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_city) {
- unicsv_print_str(GMSD_GET(city, NULL));
+ unicsv_print_str(garmin_fs_t::get_city(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_postal_code) {
- unicsv_print_str(GMSD_GET(postal_code, NULL));
+ unicsv_print_str(garmin_fs_t::get_postal_code(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_state) {
- unicsv_print_str(GMSD_GET(state, NULL));
+ unicsv_print_str(garmin_fs_t::get_state(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_country) {
- unicsv_print_str(GMSD_GET(country, NULL));
+ unicsv_print_str(garmin_fs_t::get_country(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_phone_nr) {
- unicsv_print_str(GMSD_GET(phone_nr, NULL));
+ unicsv_print_str(garmin_fs_t::get_phone_nr(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_phone_nr2) {
- unicsv_print_str(GMSD_GET(phone_nr2, NULL));
+ unicsv_print_str(garmin_fs_t::get_phone_nr2(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_fax_nr) {
- unicsv_print_str(GMSD_GET(fax_nr, NULL));
+ unicsv_print_str(garmin_fs_t::get_fax_nr(gmsd, nullptr));
}
if FIELD_USED(fld_garmin_email) {
- unicsv_print_str(GMSD_GET(email, NULL));
+ unicsv_print_str(garmin_fs_t::get_email(gmsd, nullptr));
}
if (wpt->EmptyGCData()) {
return 0;
}
- if ((gmsd = GMSD_FIND(A)) && (gmsd->ilinks != nullptr)) {
+ if ((gmsd = garmin_fs_t::find(A)) && (gmsd->ilinks != nullptr)) {
garmin_ilink_t* link = gmsd->ilinks;
res = gcgeodist(A->latitude, A->longitude, link->lat, link->lon);
static garmin_fs_t*
gmsd_init(Waypoint* wpt)
{
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
if (gmsd == nullptr) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&wpt->fs, (format_specific_data*) gmsd);
/* usage: xcsv_parse_val("-123.34", *waypt, *field_map) */
/*****************************************************************************/
static void
-xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp,
+xcsv_parse_val(const QString& value, Waypoint* wpt, const field_map& fmp,
xcsv_parse_data* parse_data, const int line_no)
{
const char* enclosure = "";
if (0 == strcmp(fmp.printfc.constData(), "\"%s\"")) {
enclosure = "\"";
}
+
+ // TODO: eliminate this char string usage.
+ QByteArray value_utf8 = value.toUtf8();
+ const char* s = value_utf8.constData();
+
switch (fmp.hashed_key) {
case XT_IGNORE:
/* IGNORE -- Categorically ignore this... */
if (!parse_data->link_) {
parse_data->link_ = new UrlLink;
}
- parse_data->link_->url_ = QString(s).trimmed();
+ parse_data->link_->url_ = value.trimmed();
break;
case XT_URL_LINK_TEXT:
if (!parse_data->link_) {
parse_data->link_ = new UrlLink;
}
- parse_data->link_->url_link_text_ = QString(s).trimmed();
+ parse_data->link_->url_link_text_ = value.trimmed();
break;
case XT_ICON_DESCR:
- wpt->icon_descr = QString(s).trimmed();
+ wpt->icon_descr = value.trimmed();
break;
/* LATITUDE CONVERSIONS**************************************************/
case XT_TIMET_TIME_MS: {
/* Time as time_t in milliseconds */
bool ok;
- wpt->SetCreationTime(QDateTime::fromMSecsSinceEpoch(QString(s).toLongLong(&ok)));
+ wpt->SetCreationTime(QDateTime::fromMSecsSinceEpoch(value.toLongLong(&ok)));
if (!ok) {
warning("parse of string '%s' on line number %d as TIMET_TIME_MS failed.\n", s, line_no);
}
wpt->AllocGCData()->container = gs_mkcont(s);
break;
case XT_GEOCACHE_HINT:
- wpt->AllocGCData()->hint = QString(s).trimmed();
+ wpt->AllocGCData()->hint = value.trimmed();
break;
case XT_GEOCACHE_PLACER:
- wpt->AllocGCData()->placer = QString(s).trimmed();
+ wpt->AllocGCData()->placer = value.trimmed();
break;
case XT_GEOCACHE_ISAVAILABLE:
gc_data = wpt->AllocGCData();
/* GMSD ****************************************************************/
case XT_COUNTRY: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(country, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_country(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_STATE: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(state, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_state(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_CITY: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(city, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_city(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_STREET_ADDR: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(addr, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_addr(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_POSTAL_CODE: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(postal_code, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_postal_code(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_PHONE_NR: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(phone_nr, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_phone_nr(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_FACILITY: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(facility, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_facility(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case XT_EMAIL: {
garmin_fs_t* gmsd = gmsd_init(wpt);
- GMSD_SET(email, csv_stringtrim(s, enclosure, 0));
+ garmin_fs_t::set_email(gmsd, csv_stringtrim(value, enclosure, 0));
}
break;
case -1:
/* now rip the line apart */
for (const auto& value : values) {
const field_map& fmp = xcsv_file.ifields.at(ifield_idx++);
- xcsv_parse_val(CSTR(value), wpt_tmp, fmp, &parse_data, linecount);
+ xcsv_parse_val(value, wpt_tmp, fmp, &parse_data, linecount);
if (ifield_idx >= xcsv_file.ifields.size()) {
/* no more fields, stop parsing! */
break;
/* GMSD ************************************************************/
case XT_COUNTRY: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(country, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_country(gmsd, "")));
}
break;
case XT_STATE: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(state, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_state(gmsd, "")));
}
break;
case XT_CITY: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(city, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_city(gmsd, "")));
}
break;
case XT_POSTAL_CODE: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(postal_code, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_postal_code(gmsd, "")));
}
break;
case XT_STREET_ADDR: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(addr, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_addr(gmsd, "")));
}
break;
case XT_PHONE_NR: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(phone_nr, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_phone_nr(gmsd, "")));
}
break;
case XT_FACILITY: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(facility, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_facility(gmsd, "")));
}
case XT_EMAIL: {
- garmin_fs_t* gmsd = GMSD_FIND(wpt);
- buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(email, ""));
+ garmin_fs_t* gmsd = garmin_fs_t::find(wpt);
+ buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_email(gmsd, "")));
}
break;
/* specials */
result->fs.type = type;
result->fs.copy = fs_xml_copy;
result->fs.destroy = fs_xml_destroy;
- result->fs.convert = nullptr;
return result;
}
projects / gpsbabel.git / commitdiff